﻿using System;
using System.Collections.Generic;
using NUnit.Framework;
using Studio7i.CapaDominio;
using Studio7i.CapaPersistencia.DAO;
using Studio7i.CapaPersistencia;



namespace Studio7i.CapaPruebas
{

    [TestFixture]
    public class Test_InstrumentoDAO
    {

        InstrumentoDAO instDAO = null;
        private int codigoGenerado = 4;

        [TestFixtureSetUp]
        public void PrepararPruebas()
        {
            //instaciamos el DAOF
            instDAO = new InstrumentoDAO();

            //eliminamos los instrumentos que hubieran en la BD
            foreach (Instrumento inst1 in instDAO.ListarTodos())
                instDAO.Eliminar(inst1);

            //creamos 3 instrumentos para pruebas
            foreach (Instrumento i in instDAO.ListarTodos()) instDAO.Eliminar(i);
            instDAO.Crear(new Instrumento() { tipo = "Guitarra", marca = "Fender", modelo = "Squier", anhoDeFabricacion = 2009, caracteristicas = "Color madera", costoDeAlquiler = 10 });
            instDAO.Crear(new Instrumento() { tipo = "Guitarra", marca = "Fender", modelo = "Stratocaster", anhoDeFabricacion = 2010, caracteristicas = "Blanca", costoDeAlquiler = 15 });
            instDAO.Crear(new Instrumento() { tipo = "Bajo", marca = "Yamaha", modelo = "Signature", anhoDeFabricacion = 2011, caracteristicas = "5 cuerdas", costoDeAlquiler = 12 });

        }
        /**********************************************************************************************************/

        [Test]
        public void Test_Crear()
        {
            Assert.IsNotNull(instDAO);
            Instrumento instACrear = new Instrumento();
            instACrear.tipo = "Piano";
            instACrear.marca = "Yamaha";
            instACrear.modelo = "X1200";
            instACrear.anhoDeFabricacion = 2010;
            instACrear.caracteristicas = "Piano de cola";
            instACrear.costoDeAlquiler = 300;

            Instrumento instCreado = null;


            // Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                instCreado = instDAO.Crear(instACrear);
                codigoGenerado = instCreado.codigo;
            }, "local creado");

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(instCreado);

            // Probamos que el código generado sea mayor a 0
            Assert.GreaterOrEqual(instCreado.codigo, 0);

            // Probamos que el nombre registrado es igual al solicitado con la entidad
            Assert.AreEqual(instCreado.tipo, instACrear.tipo);

        }
        /**********************************************************************************************************/

        [Test]
        public void Test_Obtener()
        {
            int codigo = codigoGenerado;
            Assert.IsNotNull(instDAO);

            Instrumento instObtenido = null;
            // Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                instObtenido = instDAO.Obtener(codigo);
            });

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(instObtenido);

            Assert.AreEqual(instObtenido.codigo, codigo);
            Assert.IsNotNullOrEmpty(instObtenido.tipo);
            Assert.IsNotNullOrEmpty(instObtenido.marca);
            Assert.IsNotNullOrEmpty(instObtenido.modelo);
            Assert.IsNotNull(instObtenido.anhoDeFabricacion);
            Assert.IsNotNullOrEmpty(instObtenido.caracteristicas);
            Assert.IsNotNull(instObtenido.costoDeAlquiler);
        }
        /**********************************************************************************************************/

        [Test]
        public void Test_Modificar()
        {
            //Assert.IsNotNull(instDAO);
            codigoGenerado = 1;
            // Declaramos e instanciamos la entidad de dominio
            Instrumento instAModificar = instDAO.Obtener(codigoGenerado);
            instAModificar.codigo = codigoGenerado;
            instAModificar.tipo = "Guitarra";
            instAModificar.marca = "Ybañez";
            instAModificar.modelo = "Super G";
            instAModificar.anhoDeFabricacion = 2005;
            instAModificar.caracteristicas = "Guitarra de aluminio";
            instAModificar.costoDeAlquiler = 30;

            // Declaramos la entidad que contendrá el resultado
            Instrumento instModificado = null;

            // Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                instModificado = instDAO.Modificar(instAModificar);
            }, "instrumento modificado");

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(instModificado);

            // Probamos que el código generado sea mayor a 0
            Assert.Greater(instModificado.codigo, 0);
        }

        /**********************************************************************************************************/
        [Test]
        public void Test_Eliminar()
        {
            Assert.IsNotNull(instDAO);

            // Definimos la entidad que contendrá el resultado
            Instrumento instExistente = instDAO.Obtener(2);//(codigoGenerado);

            // Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                instDAO.Eliminar(instExistente);
            });

            // Probamos que la entidad ya no existe
            Assert.IsNull(instDAO.Obtener(2));
        }
        /**********************************************************************************************************/
        [Test]
        public void Test_ListarTodos()
        {
            Assert.IsNotNull(instDAO);
            ICollection<Instrumento> instEncontrados = null;

            // 3. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                instEncontrados = instDAO.ListarTodos();
            }, "local eliminado");

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(instEncontrados);

            // Probamos que la cantidad de instrumentos encontrados sea 
            Assert.GreaterOrEqual(instEncontrados.Count, 2);

            // Probamos que cada local contenga la cadena de búsqueda en su nombre
            foreach (Instrumento instEncontrado in instEncontrados)
            {
                Assert.IsNotNull(instEncontrado);
                Assert.IsInstanceOf(typeof(Instrumento), instEncontrado);
            }
        }
        /**********************************************************************************************************/
        [Test]
        public void Test_ListarXTipo()
        {
            Assert.IsNotNull(instDAO);
            string busqueda = "aj"; // Bajo
            ICollection<Instrumento> instEncontrados = null;

            //Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                instEncontrados = instDAO.ListarXTipo(busqueda);
            });

            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(instEncontrados);

            // Probamos que la cantidad de locales encontrados sea 
            Assert.AreEqual(instEncontrados.Count, 1);

            // Probamos que cada inst contenga la cadena de búsqueda en su nombre
            foreach (Instrumento instEncontrado in instEncontrados)
            {
                Assert.IsTrue(instEncontrado.tipo.Contains(busqueda));
            }
        }
    }
}


